/**
 * 统一的登录状态检查和用户信息管理工具
 * 作者：AI Assistant
 * 日期：2025
 */

const api = require('./api.js');

/**
 * 检查用户登录状态
 * @returns {boolean} 是否已登录
 */
function checkLoginStatus() {
  const token = wx.getStorageSync('token');
  const userId = wx.getStorageSync('userId');
  return !!(token && userId);
}

/**
 * 要求用户登录，如果未登录则跳转到登录页面
 * @param {string} redirectUrl 登录成功后的跳转地址（可选）
 * @returns {boolean} 是否已登录
 */
function requireLogin(redirectUrl = '') {
  if (!checkLoginStatus()) {
    let loginUrl = '/pages/user/login/index';
    if (redirectUrl) {
      loginUrl += '?redirect=' + encodeURIComponent(redirectUrl);
    }
    wx.navigateTo({
      url: loginUrl,
      fail: () => {
        wx.showToast({
          title: '请先登录',
          icon: 'none',
          duration: 2000
        });
      }
    });
    return false;
  }
  return true;
}

/**
 * 获取当前登录用户的基本信息
 * @returns {Object|null} 用户信息对象或null
 */
function getCurrentUser() {
  if (!checkLoginStatus()) {
    return null;
  }
  
  return {
    token: wx.getStorageSync('token'),
    userId: wx.getStorageSync('userId'),
    userInfo: wx.getStorageSync('userInfo') || {}
  };
}

/**
 * 获取用户详细信息（从API获取最新数据）
 * @param {boolean} useCache 是否优先使用缓存
 * @returns {Promise<Object|null>} 用户详细信息
 */
async function getUserInfo(useCache = true) {
  try {
    if (!checkLoginStatus()) {
      return null;
    }

    // 如果使用缓存且缓存存在
    if (useCache) {
      const cachedUserInfo = wx.getStorageSync('userInfo');
      if (cachedUserInfo && Object.keys(cachedUserInfo).length > 0) {
        return cachedUserInfo;
      }
    }

    // 从API获取最新用户信息
    const result = await api.getUserDetail();
    // api.js返回格式：{success: boolean, data: object, message: string}
		if (result && result.success && result.data) {
      // 更新本地缓存
      wx.setStorageSync('userInfo', result.data);
      return result.data;
    }
    
    // API调用失败，尝试使用缓存
    const cachedUserInfo = wx.getStorageSync('userInfo');
    if (cachedUserInfo) {
      console.warn('API获取用户信息失败，使用缓存数据');
      return cachedUserInfo;
    }
    
    return null;
  } catch (error) {
    console.error('获取用户信息失败:', error);
    
    // 网络错误时尝试使用缓存
    const cachedUserInfo = wx.getStorageSync('userInfo');
    if (cachedUserInfo) {
      console.warn('网络错误，使用缓存用户信息');
      return cachedUserInfo;
    }
    
    return null;
  }
}

/**
 * 格式化用户余额显示
 * @param {number} balance 余额（分）
 * @returns {string} 格式化后的余额字符串
 */
function formatBalance(balance) {
  if (typeof balance !== 'number' || isNaN(balance)) {
    return '0.00';
  }
  return (balance / 100).toFixed(2);
}

/**
 * 格式化用户昵称显示
 * @param {Object} userInfo 用户信息对象
 * @returns {string} 格式化后的昵称
 */
function formatNickName(userInfo) {
  if (!userInfo) {
    return '用户';
  }
  
  // 优先使用接口返回的昵称
  if (userInfo.nickName) {
    return userInfo.nickName;
  }
  
  // 其次使用缓存的昵称
  const cachedUserInfo = wx.getStorageSync('userInfo');
  if (cachedUserInfo && cachedUserInfo.nickName) {
    return cachedUserInfo.nickName;
  }
  
  return '用户';
}

/**
 * 格式化用户头像显示
 * @param {Object} userInfo 用户信息对象
 * @returns {string} 头像URL
 */
function formatAvatar(userInfo) {
  const defaultAvatar = '/assets/profile/img_user_avatar_default.png';
  
  if (!userInfo) {
    return defaultAvatar;
  }
  
  // 优先使用接口返回的头像
  if (userInfo.avatarUrl || userInfo.avatar) {
    return userInfo.avatarUrl || userInfo.avatar;
  }
  
  // 其次使用缓存的头像
  const cachedUserInfo = wx.getStorageSync('userInfo');
  if (cachedUserInfo && (cachedUserInfo.avatarUrl || cachedUserInfo.avatar)) {
    return cachedUserInfo.avatarUrl || cachedUserInfo.avatar;
  }
  
  return defaultAvatar;
}

/**
 * 清除用户登录状态和缓存信息
 */
function clearUserData() {
  try {
    wx.removeStorageSync('token');
    wx.removeStorageSync('userId');
    wx.removeStorageSync('userInfo');
    console.log('用户数据已清除');
  } catch (error) {
    console.error('清除用户数据失败:', error);
  }
}

/**
 * 用户登出
 * @param {boolean} showToast 是否显示提示
 * @param {string} redirectUrl 登出后跳转的页面
 */
function logout(showToast = true, redirectUrl = '/pages/home/index/index') {
  clearUserData();
  
  if (showToast) {
    wx.showToast({
      title: '已退出登录',
      icon: 'success',
      duration: 1500
    });
  }
  
  // 延迟跳转，确保toast显示
  setTimeout(() => {
    if (redirectUrl.startsWith('/pages/home/') || redirectUrl.startsWith('/pages/main/')) {
      // 跳转到tabbar页面
      wx.switchTab({
        url: redirectUrl,
        fail: () => {
          wx.navigateTo({
            url: redirectUrl
          });
        }
      });
    } else {
      wx.navigateTo({
        url: redirectUrl,
        fail: () => {
          wx.switchTab({
            url: '/pages/home/index/index'
          });
        }
      });
    }
  }, showToast ? 1500 : 0);
}

/**
 * 刷新用户信息缓存
 * @returns {Promise<Object|null>} 最新的用户信息
 */
async function refreshUserInfo() {
  return await getUserInfo(false); // 强制从API获取最新数据
}

/**
 * 检查并更新用户登录状态
 * 用于页面onShow时检查登录状态是否有效
 * @returns {Promise<boolean>} 登录状态是否有效
 */
async function validateLoginStatus() {
  if (!checkLoginStatus()) {
    return false;
  }
  
  try {
    // 尝试获取用户信息来验证token是否有效
    const userInfo = await getUserInfo(false);
    if (!userInfo) {
      // token可能已过期，清除登录状态
      clearUserData();
      return false;
    }
    return true;
  } catch (error) {
    console.error('验证登录状态失败:', error);
    // 网络错误时保持登录状态
    return true;
  }
}

module.exports = {
  checkLoginStatus,
  requireLogin,
  getCurrentUser,
  getUserInfo,
  formatBalance,
  formatNickName,
  formatAvatar,
  clearUserData,
  logout,
  refreshUserInfo,
  validateLoginStatus
};